{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repeat Running"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another simple but powerful function provided in ``BrainPy`` is the repeat running mode of ``brainpy.Network``. This function allows users to run a compiled network model repeatly. Specifically, each ``brainpy.Network`` is instantiated  in the repeat mode by default. Once, the input structure of the model is changed, the network will be rebiuld and recompiled. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before each function call of ``net.run()``, users can arbitrarily set the values in ``ST`` state, or the input values in ``inputs``. However, user's parameter updating ``model.pars['xx'] = xx`` can not be done. This is because BrainPy compiles the ``ST`` and ``inputs`` as dynamical variables and treat them as the functional arguments, while for the ``pars``, BrainPy recognizes them as the static variables and can not be changed after the model compilation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeat mode of ``brainpy.Network`` is very useful at least in the following two situations: *parameter searching* and *RAM memory saving*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameter Searching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``Parameter searching`` is one of the most common things in computational modeling. When creating a \n",
    "model, we'll be presented with many parameters to control how our defined model evolves. Often times, \n",
    "we don't immediately know what the optimal parameter set should be for a given model, and thus we'd \n",
    "like to be able to explore a range of possibilities. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fortunately, with the ``repeat`` mode provided in ``brainpy.Network``, parameter searching is a very easy thing. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we illustrate this with the example of [gamma oscillation](https://brainpy.readthedocs.io/en/latest/tutorials/quick_start.html), and to see how different value of ``g_max`` (the maximal synaptic conductance) affect the network coherence. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's import the necessary packages and define the models first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('../../')\n",
    "\n",
    "import brainpy as bp\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "bp.profile.set(jit=True, dt=0.04, numerical_method='exponential')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same with [gamma oscillation](https://brainpy.readthedocs.io/en/latest/tutorials/quick_start.html), the HH neuron model is defined as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# HH neuron model #\n",
    "# --------------- #\n",
    "\n",
    "V_th = 0.\n",
    "C = 1.0\n",
    "gLeak = 0.1\n",
    "ELeak = -65\n",
    "gNa = 35.\n",
    "ENa = 55.\n",
    "gK = 9.\n",
    "EK = -90.\n",
    "phi = 5.0\n",
    "\n",
    "HH_ST = bp.types.NeuState({'V': -55., 'h': 0., 'n': 0., 'spike': 0., 'inp': 0.})\n",
    "\n",
    "@bp.integrate\n",
    "def int_h(h, t, V):\n",
    "    alpha = 0.07 * np.exp(-(V + 58) / 20)\n",
    "    beta = 1 / (np.exp(-0.1 * (V + 28)) + 1)\n",
    "    dhdt = alpha * (1 - h) - beta * h\n",
    "    return phi * dhdt\n",
    "\n",
    "@bp.integrate\n",
    "def int_n(n, t, V):\n",
    "    alpha = -0.01 * (V + 34) / (np.exp(-0.1 * (V + 34)) - 1)\n",
    "    beta = 0.125 * np.exp(-(V + 44) / 80)\n",
    "    dndt = alpha * (1 - n) - beta * n\n",
    "    return phi * dndt\n",
    "\n",
    "@bp.integrate\n",
    "def int_V(V, t, h, n, Isyn):\n",
    "    m_alpha = -0.1 * (V + 35) / (np.exp(-0.1 * (V + 35)) - 1)\n",
    "    m_beta = 4 * np.exp(-(V + 60) / 18)\n",
    "    m = m_alpha / (m_alpha + m_beta)\n",
    "    INa = gNa * m ** 3 * h * (V - ENa)\n",
    "    IK = gK * n ** 4 * (V - EK)\n",
    "    IL = gLeak * (V - ELeak)\n",
    "    dvdt = (- INa - IK - IL + Isyn) / C\n",
    "    return dvdt\n",
    "\n",
    "def neu_update(ST, _t):\n",
    "    h = int_h(ST['h'], _t, ST['V'])\n",
    "    n = int_n(ST['n'], _t, ST['V'])\n",
    "    V = int_V(ST['V'], _t, ST['h'], ST['n'], ST['inp'])\n",
    "    sp = np.logical_and(ST['V'] < V_th, V >= V_th)\n",
    "    ST['spike'] = sp\n",
    "    ST['V'] = V\n",
    "    ST['h'] = h\n",
    "    ST['n'] = n\n",
    "    ST['inp'] = 0.\n",
    "\n",
    "HH = bp.NeuType(name='HH_neuron', ST=HH_ST, steps=neu_update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different from the [orignal definition](https://brainpy.readthedocs.io/en/latest/tutorials/quick_start.html), \n",
    "here we add the parameter ``g_max`` into the ``ST``, because later we will change the value of ``g_max`` and rerun the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GABAa #\n",
    "# ----- #\n",
    "\n",
    "g_max = 0.1\n",
    "E = -75.\n",
    "alpha = 12.\n",
    "beta = 0.1\n",
    "\n",
    "@bp.integrate\n",
    "def int_s(s, t, TT):\n",
    "    return alpha * TT * (1 - s) - beta * s\n",
    "\n",
    "def syn_update(ST, _t, pre):\n",
    "    T = 1 / (1 + np.exp(-(pre['V'] - V_th) / 2))\n",
    "    s = int_s(ST['s'], _t, T)\n",
    "    ST['s'] = s\n",
    "\n",
    "def syn_output(ST, post):\n",
    "    post['inp'] -= ST['g_max'] * ST['s'] * (post['V'] - E)\n",
    "\n",
    "GABAa = bp.SynType(name='GABAa',\n",
    "                   ST=bp.types.SynState(['g_max', 's']),\n",
    "                   steps=(syn_update, syn_output),\n",
    "                   requires=dict(pre=bp.types.NeuState(['V']),\n",
    "                                 post=bp.types.NeuState(['V', 'inp'])),\n",
    "                   mode='scalar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Putting the HH neuron and the GABA<sub>A</sub> syanpse together, let's define the network in which HH neurons are interconnected with the GABA<sub>A</sub> syanpses. Here, what's different is we add a term ``mode='repeat'`` into the ``bp.Network`` definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Network #\n",
    "# ------- #\n",
    "\n",
    "num = 100\n",
    "v_init = -70. + np.random.random(num) * 20\n",
    "h_alpha = 0.07 * np.exp(-(v_init + 58) / 20)\n",
    "h_beta = 1 / (np.exp(-0.1 * (v_init + 28)) + 1)\n",
    "h_init = h_alpha / (h_alpha + h_beta)\n",
    "n_alpha = -0.01 * (v_init + 34) / (np.exp(-0.1 * (v_init + 34)) - 1)\n",
    "n_beta = 0.125 * np.exp(-(v_init + 44) / 80)\n",
    "n_init = n_alpha / (n_alpha + n_beta)\n",
    "\n",
    "group = bp.NeuGroup(HH, geometry=num, monitors=['spike'])\n",
    "conn = bp.SynConn(GABAa, pre_group=group, post_group=group,\n",
    "                  conn=bp.connect.All2All(include_self=False))\n",
    "net = bp.Network(group, conn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, by using the [cross correlation](https://en.wikipedia.org/wiki/Cross-correlation) measurement, we can evaluate the network coherence under the different parameter setting of ``g_max``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "When g_max = 0.00050 ...\n",
      "Compilation used 3.0192 s.\n",
      "Start running ...\n",
      "Run 20.0% used 0.658 s.\n",
      "Run 40.0% used 1.315 s.\n",
      "Run 60.0% used 1.972 s.\n",
      "Run 80.0% used 2.632 s.\n",
      "Run 100.0% used 3.304 s.\n",
      "Simulation is done in 3.304 s.\n",
      "\n",
      "\n",
      "When g_max = 0.00060 ...\n",
      "Compilation used 0.0010 s.\n",
      "Start running ...\n",
      "Run 20.0% used 0.669 s.\n",
      "Run 40.0% used 1.333 s.\n",
      "Run 60.0% used 1.992 s.\n",
      "Run 80.0% used 2.661 s.\n",
      "Run 100.0% used 3.335 s.\n",
      "Simulation is done in 3.335 s.\n",
      "\n",
      "\n",
      "When g_max = 0.00070 ...\n",
      "When g_max = 0.00080 ...\n",
      "When g_max = 0.00090 ...\n",
      "When g_max = 0.00100 ...\n",
      "When g_max = 0.00110 ...\n",
      "When g_max = 0.00120 ...\n",
      "When g_max = 0.00130 ...\n",
      "When g_max = 0.00140 ...\n",
      "When g_max = 0.00150 ...\n"
     ]
    }
   ],
   "source": [
    "# Parameter Searching #\n",
    "# ------------------- #\n",
    "\n",
    "all_g_max = np.arange(0.05, 0.151, 0.01) / num\n",
    "all_cc = []\n",
    "\n",
    "for i, g_max in enumerate(all_g_max):\n",
    "    print('When g_max = {:.5f} ...'.format(g_max))\n",
    "    \n",
    "    group.ST['V'] = v_init\n",
    "    group.ST['h'] = h_init\n",
    "    group.ST['n'] = n_init\n",
    "    group.ST['spike'] = 0.\n",
    "    group.ST['inp'] = 0.\n",
    "    \n",
    "    conn.ST['s'] = 0.\n",
    "    conn.ST['g_max'] = g_max\n",
    "    \n",
    "    report = i < 2\n",
    "    net.run(duration=500., inputs=[group, 'ST.inp', 1.2], report=report, report_percent=0.2)\n",
    "\n",
    "    cc = bp.measure.cross_correlation(group.mon.spike, bin_size=int(0.5 / bp.profile.get_dt()))\n",
    "    all_cc.append(cc)\n",
    "    \n",
    "    if report: print('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the network was only compiled at the fist time run. And the overall speed of the later running does not change."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can plot the relationship between the ``g_max`` and network coherence ``cc``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(all_g_max, all_cc)\n",
    "plt.xlabel('g_max')\n",
    "plt.ylabel('cc')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is worthy to note that in this example, before each ``net.run()``, we reset the ``ST`` state of the neuron group and the synaptical connection. This is because each repeat run is independent with each other in the case of the parameter tuning. However, in the following example, the current ``net.run()`` relies on the previous network running, the ``ST`` state should not be reset. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Memory Saving"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another annoyance often occurs is that our computers have limited RAM memory. Once the model size is big, or the running duration is long, ``MemoryError`` usually occurs. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, with ``brainpy.Network`` repeat running mode, BrainPy can partially solve this problem by allowing uers to split a long duration into multiple short durations. BrainPy allows user to repeatedly call ``run()``, **but with the same ``inputs`` structure**. In this section, we illustrate this function by using the above defined gamma oscillation network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a network with the size of 200 HH neurons, and try to run this network in 2 seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 200\n",
    "v_init = -70. + np.random.random(num) * 20\n",
    "h_alpha = 0.07 * np.exp(-(v_init + 58) / 20)\n",
    "h_beta = 1 / (np.exp(-0.1 * (v_init + 28)) + 1)\n",
    "h_init = h_alpha / (h_alpha + h_beta)\n",
    "n_alpha = -0.01 * (v_init + 34) / (np.exp(-0.1 * (v_init + 34)) - 1)\n",
    "n_beta = 0.125 * np.exp(-(v_init + 44) / 80)\n",
    "n_init = n_alpha / (n_alpha + n_beta)\n",
    "\n",
    "group = bp.NeuGroup(HH, geometry=num, monitors=['spike'])\n",
    "conn = bp.SynConn(GABAa, pre_group=group, post_group=group,\n",
    "                  conn=bp.connect.All2All(include_self=False))\n",
    "net = bp.Network(group, conn)\n",
    "\n",
    "group.ST['V'] = v_init\n",
    "group.ST['h'] = h_init\n",
    "group.ST['n'] = n_init\n",
    "\n",
    "conn.ST['g_max'] = 0.1 / num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we do not run the total 2 second at one time. On the contrary, we run the model with four steps, with each step of 0.5 second running duration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compilation used 3.2405 s.\n",
      "Start running ...\n",
      "Run 20.0% used 2.605 s.\n",
      "Run 40.0% used 5.107 s.\n",
      "Run 60.0% used 7.631 s.\n",
      "Run 80.0% used 10.152 s.\n",
      "Run 100.0% used 12.653 s.\n",
      "Simulation is done in 12.653 s.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run 1: 0 - 500 ms\n",
    "\n",
    "net.run(duration=(0., 500.), inputs=[group, 'ST.inp', 1.2], report=True, report_percent=0.2)\n",
    "bp.visualize.raster_plot(net.ts, group.mon.spike, show=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compilation used 0.0020 s.\n",
      "Start running ...\n",
      "Run 20.0% used 2.500 s.\n",
      "Run 40.0% used 5.018 s.\n",
      "Run 60.0% used 7.506 s.\n",
      "Run 80.0% used 10.019 s.\n",
      "Run 100.0% used 12.524 s.\n",
      "Simulation is done in 12.524 s.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run 2: 500 - 1000 ms\n",
    "\n",
    "net.run(duration=(500., 1000.), inputs=[group, 'ST.inp', 1.2], report=True, report_percent=0.2)\n",
    "bp.visualize.raster_plot(net.ts, group.mon.spike, show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set a different inputs structure, the network will ne rebuild and recompiled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The current \"ST.inp\" input shape (200,) is different from the last input shape (). The network will be recompiled.\n",
      "The network will be rebuild.\n",
      "Compilation used 3.0360 s.\n",
      "Start running ...\n",
      "Run 20.0% used 2.507 s.\n",
      "Run 40.0% used 5.002 s.\n",
      "Run 60.0% used 7.504 s.\n",
      "Run 80.0% used 10.014 s.\n",
      "Run 100.0% used 12.521 s.\n",
      "Simulation is done in 12.521 s.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEGCAYAAACZ0MnKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAXQklEQVR4nO3df7RdZX3n8fdHUCxWRzAXGvkxCUx0FWWM5MKUWpVqp6Bt+WFFYamlLavRGVhjR50K4hKmLWMFKV1agRULS6wIUpFKpygw1Mq4RsQbGiAYUgKiRGJyUVtxwkQD3/nj7GtO4r03Ozf3/Mi979dad519nr2f83wfQu4n+8fZO1WFJEltPGPQBUiS9hyGhiSpNUNDktSaoSFJas3QkCS1tvegC9gdCxYsqEWLFg26DEnao6xcufLxqhqZSd89OjQWLVrE2NjYoMuQpD1Kkm/NtK+HpyRJrRkakqTWDA1JUmuGhiSptZ6FRpJDknwpyZok9yd5Z9O+f5LbkjzYvO7X1efcJOuSrE1yfK9qkyTNTC/3NLYC766qXwR+CTgryRHAOcDtVbUEuL15T7PuNOAlwAnAZUn26mF9kqRd1LPQqKoNVXV3s/wEsAY4CDgJuLrZ7Grg5Gb5JOC6qtpSVd8E1gHH9Ko+SdKu68s5jSSLgJcDXwMOrKoN0AkW4IBms4OAR7u6rW/advys5UnGkoyNj4/PuKbHH3+ciy++mMcff7wv/Rxz+Po5pmPOtzFnRVX19Af4eWAl8Ibm/b/ssP4HzevHgLd2tV8J/PZ0n71s2bKaqfPPP7+AOv/88/vSzzGHr59jOuZ8G3MCMFYz/J3e0z2NJM8EbgCuqarPNc0bkyxs1i8ENjXt64FDurofDDzWq9o2b9683Wuv+znm8PVzTMecb2POhl5ePRU6ewtrqurPu1bdBJzRLJ8BfL6r/bQk+yRZDCwB7upVfZKkXdfLe0+9AngbcF+SVU3b+4A/A65PcibwbeBUgKq6P8n1wDfoXHl1VlU91cP6JEm7qGehUVVfATLF6tdO0edC4MJe1SRJ2j1+I1yS1JqhIUlqzdCQJLVmaEiSWjM0JEmtGRqSpNYMDUlSa4aGJKk1Q0OS1JqhIUlqzdCQJLVmaEiSWjM0JEmtGRqSpNYMDUlSa4aGJKm1Xj7u9aokm5Ks7mr7TJJVzc8jE0/0S7IoyZNd667oVV2SpJnr5eNePwH8JfDJiYaqevPEcpJLgH/t2v6hqlraw3okSbupl497vSPJosnWJQnwJuA1vRpfkjT7BnVO45XAxqp6sKttcZJ/SvLlJK+cqmOS5UnGkoyNj4/3vlJJ0k8NKjROB67ter8BOLSqXg68C/h0kudN1rGqVlTVaFWNjoyM9KFUSdKEvodGkr2BNwCfmWirqi1V9b1meSXwEPCiftcmSZreIPY0fg14oKrWTzQkGUmyV7N8GLAEeHgAtUmSptHLS26vBb4KvDjJ+iRnNqtOY/tDUwCvAu5Ncg/wWeAdVfX9XtUmSZqZXl49dfoU7b87SdsNwA29qkWSNDv8RrgkqTVDQ5LUmqEhSWrN0JAktWZoSJJaMzQkSa0ZGpKk1gwNSVJrhoYkqTVDQ5LUmqEhSWrN0JAktWZoSJJaMzQkSa0ZGpKk1gwNSVJrvXxy31VJNiVZ3dV2QZLvJFnV/Ly+a925SdYlWZvk+F7VJUmauV7uaXwCOGGS9kuramnzczNAkiPoPAb2JU2fyyaeGS5JGh49C42qugNo+5zvk4DrqmpLVX0TWAcc06vaJEkzM4hzGmcnubc5fLVf03YQ8GjXNuubtp+RZHmSsSRj4+Pjva5VktSl36FxOXA4sBTYAFzStGeSbWuyD6iqFVU1WlWjIyMjPSlSkjS5voZGVW2sqqeq6mng42w7BLUeOKRr04OBx/pZmyRp5/oaGkkWdr09BZi4suom4LQk+yRZDCwB7upnbZKkndu7Vx+c5FrgOGBBkvXA+cBxSZbSOfT0CPB2gKq6P8n1wDeArcBZVfVUr2qTJM1Mz0Kjqk6fpPnKaba/ELiwV/VIknaf3wiXJLVmaEiSWjM0JEmtGRqSpNYMDUlSa4aGJKk1Q0OS1JqhIUlqzdCQJLVmaEiSWjM0JEmtGRqSpNZ2GhrN87t3bDuuF8VIkoZbmz2N65O8Nx0/l+SjwAd7XZgkafi0CY3/QOepev8H+DqdJ+q9opdFSZKGU5vQ+AnwJPBzwLOBbzaPa5UkzTNtQuPrdELjaOBXgNOTfHZnnZJclWRTktVdbRcneSDJvUluTPL8pn1RkieTrGp+rpjZdCRJvdQmNM6sqg9U1U+q6rtVdRLw+Rb9PgGcsEPbbcBLq+rfA/8MnNu17qGqWtr8vKNN8ZKk/moTGiuTvDXJBwCSHAqs3VmnqroD+P4ObbdW1dbm7Z3AwbtYryRpgNqExmXAscDEM7+fAD42C2P/PvCFrveLk/xTki8neeVUnZIsTzKWZGx8fHwWypAktdXq6qmqOgv4fwBV9QPgWbszaJLzgK3ANU3TBuDQqno58C7g00meN1nfqlpRVaNVNToyMrI7ZUiSdlGrq6eS7AUUQJIRYMZXTyU5A/hN4C1VVQBVtaWqvtcsrwQeAl400zEkSb3RJjQ+AtwIHJDkQuArwP+YyWBJTgDeC5xYVZu72keaYCLJYcAS4OGZjCFJ6p29d7ZBVV2TZCXwWiDAyVW1Zmf9klwLHAcsSLIeOJ/O1VL7ALclAbizuVLqVcAfJ9kKPAW8o6q+P+kHS5IGZsrQSLJ/19tNwLXd63b2S72qTp+k+coptr0BuGH6UiVJgzbdnsZKOucxAhwK/KBZfj7wbWBxr4uTJA2XKc9pVNXiqjoMuAX4rapaUFUvoHMS+3P9KlCSNDzanAg/uqpunnhTVV8AXt27kiRJw2qnJ8KBx5O8H/gUncNVbwW+19OqJElDqc2exunACJ3Lbv8WOIBt3w6XJM0jbS65/T7wzj7UIkkacjsNjSQvAt4DLOrevqpe07uyJEnDqM05jb8BrgD+is4X7yRJ81Sb0NhaVZf3vBJJ0tBrcyL875L85yQLk+w/8dPzyiRJQ6fNnsYZzet/62or4LDZL0eSNMzaXD3l7UIkScD0Nyx8TVX9Q5I3TLa+qryViCTNM9Ptabwa+AfgtyZZV3j/KUmad6YMjao6v3n9vf6VI0kaZm2unpqRJFcl2ZRkdVfb/kluS/Jg87pf17pzk6xLsjbJ8b2qS5I0cz0LDeATwAk7tJ0D3F5VS4Dbm/ckOQI4DXhJ0+eyice/SpKGR89Co6ruAHZ8ut9JwNXN8tXAyV3t11XVlqr6JrAOOKZXtUmSZqbN9zRI8sv87L2nPjmD8Q6sqg1N/w1JDmjaDwLu7NpufdMmSRoibW5Y+NfA4cAqtt17qoCZhMaUw0zSVlPUsxxYDnDooYfOYgmSpJ1ps6cxChxRVZP+Et9FG5MsbPYyFgKbmvb1wCFd2x0MPDbZB1TVCmAFwOjo6GzUJElqqc05jdXAL8zSeDex7bYkZwCf72o/Lck+SRYDS4C7ZmlMSdIsabOnsQD4RpK7gC0TjVV14nSdklwLHAcsSLIeOB/4M+D6JGcC3wZObT7r/iTXA98AtgJnVZW3YZekIdMmNC6YyQdX1VSPhH3tFNtfCFw4k7EkSf3R5oaFX05yIHB003RXVW2aro8kaW7a6TmNJG+ic37hVOBNwNeSvLHXhUmShk+bw1PnAUdP7F0kGQH+F/DZXhYmSRo+ba6eesYOh6O+17KfJGmOabOn8cUktwDXNu/fDNzcu5IkScNq2tBIEuAjdE6C/wqdb26vqKob+1CbJGnITBsaVVVJ/raqljHHHrq0efPm7V573c8xh6+fYzrmfBtzNrQ5N3FnkqN3vtme5b777tvutdf9HHP4+jmmY863MWdDm9D4VeCrSR5Kcm+S+5Lc2+vCeu3II4/c7rXX/Rxz+Po5pmPOtzFnQ5sT4a/reRUDsO+++2732ut+jjl8/RzTMefbmLOhTWh4J1lJEtAuNP6eTnAEeDawGFhL59GskqR5pM29p7Y7aJbkKODtPatIkjS0dvmb3VV1N9tuXihJmkfaPO71XV1vnwEcBYz3rCJJ0tBqc07juV3LW+mc47ihN+VIkoZZm3Ma/x0gyXOq6v/u7oBJXgx8pqvpMOADwPOBP2DbXsz7qsp7XEnSEGnzPI1jk3wDWNO8f1mSy2Y6YFWtraqlVbUUWAZsBibuZXXpxDoDQ5KGT5sT4X8BHE/nluhU1T3Aq2Zp/NcCD1XVt2bp8yRJPdTq6qmqenSHpqdmafzT2HbLdYCzm1uVXJVkv8k6JFmeZCzJ2Pi45+MlqZ/ahMajSX4ZqCTPSvIemkNVuyPJs4ATgb9pmi4HDgeWAhuASybrV1Urqmq0qkZHRkZ2twxJ0i5oExrvAM4CDgLW0/mlftYsjP064O6q2ghQVRur6qmqehr4OHDMLIwhSZpFba6eehx4Sw/GPp2uQ1NJFlbVhubtKcDqHowpSdoNU4ZGkg9M06+q6k9mOmiSfYH/yPa3I7koyVI697l6BG9VIklDZ7o9jcm+k/Ec4EzgBcCMQ6OqNjef0d32tpl+niSpP6YMjar66YnoJM8F3gn8HnAdU5ykliTNbdOe00iyP/AuOuc0rgaOqqof9KMwSdLwme6cxsXAG4AVwJFV9aO+VSVJGkrTXXL7buCFwPuBx5L8sPl5IskP+1OeJGmYTHdOY5eftSFJmtsMBklSa4aGJKk1Q0OS1JqhIUlqzdCQJLVmaEiSWjM0JEmtGRqSpNYMDUlSa4aGJKk1Q0OS1NpOH/faC0keAZ4AngK2VtVocxv2zwCL6Dy5703ehl2Shssg9zR+taqWVtVo8/4c4PaqWgLc3ryXJA2RYTo8dRKdBz3RvJ48uFIkSZMZVGgUcGuSlUmWN20HVtUGgOb1gMk6JlmeZCzJ2Pj4eJ/KlSTBgM5pAK+oqseSHADcluSBth2ragWdpwkyOjpavSpQkvSzBrKnUVWPNa+bgBuBY4CNSRYCNK+bBlGbJGlqfQ+NJM9J8tyJZeDXgdXATcAZzWZnAJ/vd22SpOkN4vDUgcCNSSbG/3RVfTHJ14Hrk5wJfBs4dQC1SZKm0ffQqKqHgZdN0v494LX9rkeS1N4wXXIrSRpyhoYkqTVDQ5LUmqEhSWrN0JAktWZoSJJaMzQkSa0ZGpKk1gwNSVJrhoYkqTVDQ5LUmqEhSWrN0JAktWZoSJJaMzQkSa0ZGpKk1gbxuNdDknwpyZok9yd5Z9N+QZLvJFnV/Ly+37VJkqY3iMe9bgXeXVV3N88KX5nktmbdpVX14QHUJElqYRCPe90AbGiWn0iyBjio33VIknbdQM9pJFkEvBz4WtN0dpJ7k1yVZL8p+ixPMpZkbHx8vF+lSpIYYGgk+XngBuAPq+qHwOXA4cBSOnsil0zWr6pWVNVoVY2OjIz0q1xJEgMKjSTPpBMY11TV5wCqamNVPVVVTwMfB44ZRG2SpKkN4uqpAFcCa6rqz7vaF3Ztdgqwut+1SZKmN4irp14BvA24L8mqpu19wOlJlgIFPAK8fQC1SZKmMYirp74CZJJVN/e7FknSrvEb4ZKk1gwNSVJrhoYkqTVDQ5LUmqEhSWrN0JAktWZoSJJaMzQkSa0ZGpKk1gwNSVJrhoYkqTVDQ5LUmqEhSWrN0JAktWZoSJJaMzQkSa0NXWgkOSHJ2iTrkpwz6HokSdsMVWgk2Qv4GPA64Ag6j4A9YrBVSZImDFVoAMcA66rq4ar6MXAdcNKAa5IkNYYtNA4CHu16v75p+6kky5OMJRkbHx+f8UD77rvvdq+97ueYw9fPMR1zvo05K6pqaH6AU4G/6nr/NuCjU22/bNmymqnx8fG66KKLanx8vC/9HHP4+jmmY863MScAYzXD39Pp9B8OSY4FLqiq45v35wJU1Qcn2350dLTGxsb6WKEk7fmSrKyq0Zn0HbbDU18HliRZnORZwGnATQOuSZLU2HvQBXSrqq1JzgZuAfYCrqqq+wdcliSpMVShAVBVNwM3D7oOSdLPGrbDU5KkIWZoSJJaMzQkSa0ZGpKk1obqexq7Ksk48K1d6LIAeLxH5Qy7+Tx3cP7O3/l3z//fVtXITD5ojw6NXZVkbKZfaNnTzee5g/N3/s5/tubv4SlJUmuGhiSptfkWGisGXcAAzee5g/N3/vPbrM1/Xp3TkCTtnvm2pyFJ2g2GhiSptT06NJJclWRTktVdbfsnuS3Jg83rfl3rzk2yLsnaJMd3tS9Lcl+z7iNJ0u+5zMQU8z81yf1Jnk4yusP282H+Fyd5IMm9SW5M8vyudfNh/n/SzH1VkluTvLBr3ZyZ/2Rz71r3niSVZEFX25yZO0z5Z39Bku80f/arkry+a93szX+mT28ahh/gVcBRwOqutouAc5rlc4APNctHAPcA+wCLgYeAvZp1dwHHAgG+ALxu0HPbjfn/IvBi4B+B0a72+TL/Xwf2bpY/NA///J/XtfxfgCvm4vwnm3vTfgidRyt8C1gwF+c+zZ/9BcB7Jtl2Vue/R+9pVNUdwPd3aD4JuLpZvho4uav9uqraUlXfBNYBxyRZSOcv2ler81/xk119htpk86+qNVW1dpLN58v8b62qrc3bO4GDm+X5Mv8fdr19DjBxpcucmv8Uf/cBLgX+iG3zhjk2d5h2/pOZ1fnv0aExhQOragNA83pA034Q8GjXduubtoOa5R3b55r5OP/fp/OvJ5hH809yYZJHgbcAH2ia5/z8k5wIfKeq7tlh1Zyfe5ezm8OTV3Udmp/V+c/F0JjKZMfqapr2uWZezT/JecBW4JqJpkk2m5Pzr6rzquoQOnM/u2me0/NPsi9wHttCcrvVk7TNmbl3uRw4HFgKbAAuadpndf5zMTQ2NrtdNK+bmvb1dI53TjgYeKxpP3iS9rlm3sw/yRnAbwJvaXa7YR7Nv8ungd9uluf6/A+nc7z+niSP0JnH3Ul+gbk/dwCqamNVPVVVTwMfB45pVs3q/OdiaNwEnNEsnwF8vqv9tCT7JFkMLAHuag5hPZHkl5orB36nq89cMi/mn+QE4L3AiVW1uWvVfJn/kq63JwIPNMtzev5VdV9VHVBVi6pqEZ1fiEdV1XeZ43OfMPGP5cYpwMSVVbM7/0FfBbCbVxBcS2c37Cd0/ic5E3gBcDvwYPO6f9f259G5cmAtXVcJAKPNf+CHgL+k+ab8sP9MMf9TmuUtwEbglnk2/3V0jt+uan6umGfzv6GZy73A3wEHzcX5Tzb3HdY/QnP11Fyb+zR/9n8N3Nf82d8ELOzF/L2NiCSptbl4eEqS1COGhiSpNUNDktSaoSFJas3QkCS1ZmhoXkrygq67gX636+6gP0pyWY/G/MMkvzMLn3PdDt/HkPrGS2417yW5APhRVX24h2PsDdxN5wtnW3e2/U4+69XAW6vqD2alOGkXuKchdUlyXJL/2SxfkOTq5rkUjyR5Q5KLmucPfDHJM5vtliX5cpKVSW7Z4Zu5E14D3D0RGEn+McmlSe5IsibJ0Uk+l85zYP602eY5Sf4+yT1JVid5c/NZ/xv4tSaIpL4yNKTpHQ78Bp3bS38K+FJVHQk8CfxGExwfBd5YVcuAq4ALJ/mcVwArd2j7cVW9CriCzu0bzgJeCvxukhcAJwCPVdXLquqlwBcBqnNvoXXAy2Z1plILhoY0vS9U1U/o3J5hL5pf3M37RXQeePVS4LYkq4D3s/1N4CYsBMZ3aLup67Pur6oNVbUFeJjODebuo7NH8aEkr6yqf+3quwl4IVKfuXsrTW8LdP51n+Qnte0k4NN0/v6Ezi/8Y3fyOU8Cz57ss5vP2tLV/jSdpw/+c5JlwOuBDya5tar+uNnm2c1nSn3lnoa0e9YCI0mOBUjyzCQvmWS7NcC/25UPTuf53pur6lPAh+k83nPCi4D7Z1ayNHPuaUi7oap+nOSNwEeS/Bs6f6f+gp/9hf4FOnch3RVHAhcneZrO3Uz/E0CSA4Enq3lCpdRPXnIr9UmSG4E/qqoHd/Nz/ivww6q6cnYqk9rz8JTUP+fQOSG+u/4FuHoWPkfaZe5pSJJac09DktSaoSFJas3QkCS1ZmhIklozNCRJrf1/m2VIVIff/TIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# run 1000 - 1500 ms\n",
    "\n",
    "Iext = np.ones(num) * 1.2\n",
    "net.run(duration=(1000., 1500.), inputs=[group, 'ST.inp', Iext], \n",
    "        report=True, report_percent=0.2)\n",
    "bp.visualize.raster_plot(net.ts, group.mon.spike, show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another thing worthy noting is that if the model ``ST`` state relies on the time (for example, the LIF neuron model ``ST['t_last_spike']``). Setting the continuous time duration between each repeat run is necessary, because the model's logic is dependent on the current time ``_t``. However, in this gamma oscillation network, although we set the duration as ``duration=500.`` (not ``duration=(1000., 1500.)``) in the third repeat run, the model will also produce the correct results. This is because the network running logic is independent with the current time ``_t``."
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
